/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.market.datos;

import java.util.*;
import java.sql.*;

/**
 * Esta clase contiene los atributos y métodos para interactuar con la 
 * base de datos como transacciones, consultas sql, disparadores, procedimientos 
 * del Proyecto MarketFarm
 * @author Bambino
 */
public class cDatos {

    // Conexion con Mysql 
    private final String driver = "com.mysql.jdbc.Driver";
    /*
    private final String url = "jdbc:mysql://localhost:3306/marketfarm";
    private final String user = "root";
    private final String pasw = "root";
    */
    
    
    //"jdbc:mysql://localhost/rmirc20_MarketFarmData","rmirc20","1qaz2wsx"
    private final String url = "jdbc:mysql://localhost/rmirc20_MarketFarmData";
    private final String user = "rmirc20";
    private final String pasw = "1qaz2wsx";
    
    
      
    private Connection conexion;
     

    /**
     * Crea una nueva instancia de la clase cDatos
     */
    public cDatos() {
    }

    /**
     * Inicializamos una una nueva conexion con la base de datos
     */
    public void openConnection() {
        try {
            Class.forName(driver);
            this.conexion = DriverManager.getConnection(url, user, pasw);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Cierra la conexion con la Base de datos
     */
    public void closeConnection() {
        try {
            // cierra la conexion 
            this.conexion.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * Inicia una transacción
     * @throws java.sql.SQLException
     */
    public void IniciarTransaccion() throws SQLException {
        this.conexion.setAutoCommit(false);
    }
   
    /**
     * Finaliza una transacción y graba los cambios
     * @throws java.sql.SQLException
     */
    public void FinalizarTransaccion() throws SQLException {
    this.conexion.commit();
    this.conexion.setAutoCommit(true);
    }
    
    /**
     * Deshace los cambios de una transacción
     * @throws java.sql.SQLException
     */
    public void DeshacerTransaccion() throws SQLException {
        this.conexion.rollback();
    }

    /**
     * Establece AutoCommit
     * @param estado
     * @throws java.sql.SQLException
     */
    public void EstablecerAutoCommit(boolean estado) throws SQLException {
        this.conexion.setAutoCommit(estado);
    }

    /**
     * Devuelve el valor actual de la propiedad 'conexion'
     * @return
     */
    public Connection getConnection() {
        return conexion;
    }

    /**
     * Establece externamente el valor de la propiedad 'conexion'
     * @param conexion Parámetros para la conexion con la base de datos
     */
    public void setConnection(Connection conexion) {
        this.conexion = conexion;
    }

    /**
     * Convierte un ResultSet a un Vector 
     * @param rs ResultSet registros de la base de datos
     * @return vector del registro de la base de datos
     * @throws java.sql.SQLException
     */
    private Vector ResultSetToVector(ResultSet rs) throws SQLException {
        Vector vRows = new Vector();
        // lee registro por registro 
        while (rs.next()) {
            Vector vCol = new Vector();
            // lee cada campo del query 
            int nroFields = rs.getMetaData().getColumnCount();
            for (int i = 1; i <= nroFields; i++) {
                String strTmp = rs.getString(i);
                vCol.add(strTmp);
            }
            vRows.add(vCol);
        }
        return vRows;
    }
  
    /**
     * Ejecuta delete,insert ó update
     * @param str Sentencia a ejecutar en la base de datos
     */
    private void performance(String str) {
        try {
            // crea el statement 
            Statement stmt = this.conexion.createStatement();
            // ejecuta el update 
            stmt.executeUpdate(str);
            //cierra statement 
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * Ejecuta solo los query 
     * @param strQuery Sentencia sql a ejecutar
     * @return vector de consulta
     */
    public Vector query(String strQuery) {
        Vector vRet = null;
        try {
            // crea el statement 
            Statement stmt = this.conexion.createStatement();
            // ejecuta el query 
            ResultSet rs = stmt.executeQuery(strQuery);
            // convierte el ResultSet to Vector 
            vRet = ResultSetToVector(rs);
            // cierra el ResultSet 
            rs.close();
            // cierra el statement 
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return vRet;
    }
    
    /**
     * Ejecuta un delete
     * @param strDelete String para ejecutar delete
     */
    public void delete(String strDelete) {
        performance(strDelete);
    }

    /**
     * Ejecuta un update
     * @param strUpdate String para ejecutar update
     */
    public void update(String strUpdate) {
        performance(strUpdate);
    }

    /**
     * Ejecuta un insert
     * @param strInsert String para ejecutar insert
     */
    public void insert(String strInsert) {
        performance(strInsert);
    }
 
    /**
     * SQL con parametros
     * @param str String para el Statement
     * @param aParam Arreglo de Parámetros para la sentencia a ejecutar
     */
    public void performance(String str, String aParam[]) {
        PreparedStatement pstm;
        try {
            // crea el statement 
            pstm = this.conexion.prepareStatement(str);
            // ejecuta el update
            for (int xc = 0; xc < aParam.length; xc++) {
                pstm.setString(xc + 1, aParam[xc]);
            }
            pstm.executeUpdate();
            //cierra statement 
            pstm.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * Retorna el Vector de la consulta realizada 
     * @param strQuery  String de la Consulta
     * @param xcod Parámetro para ejecutar la consulta 
     * @return
     */
    public Vector query(String strQuery, String xcod) {
        Vector vRet = null;
        try {
            // crea el statement 
            PreparedStatement pstm = this.conexion.prepareStatement(strQuery);
            // Inicializa parametros
            pstm.setString(1, xcod);
            // ejecuta el query 
            ResultSet rs = pstm.executeQuery();
            // convierte el ResultSet to Vector 
            vRet = ResultSetToVector(rs);
            // cierra el ResultSet 
            rs.close();
            // cierra el statement 
            pstm.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return vRet;
    }

    /**
     * Ejecuta la sentencia Delete
     * @param strDelete String para Delete
     * @param aParam Arreglo de parámetros para Delete
     */
    public void delete(String strDelete, String aParam[]) {
        performance(strDelete, aParam);
    }

    /**
     * Ejecuta la sentencia Update 
     * @param strUpdate String para Udpate
     * @param aParam Arreglo de parámetros para Update
     */
    public void update(String strUpdate, String aParam[]) {
        performance(strUpdate, aParam);
    }

    /**
     * Ejecuta la sentencia Insert 
     * @param strInsert String para Insert
     * @param aParam Arreglo de parámetros para Insert
     */
    public void insert(String strInsert, String aParam[]) {
        performance(strInsert, aParam);
    }

    /**
     * Ejecuta procedimientos almacenados
     * @param sp_name Nombre del procedimiento almancenado
     * @param aParam Arreglo de Parámetros del procedimiento almacenado
     */
    public void sp_proc(String sp_name, String aParam[]) {
        try {
            CallableStatement cs = this.conexion.prepareCall(sp_name);
            for (int xc = 0; xc < aParam.length; xc++) {
                cs.setString(xc + 1, aParam[xc]);
            }
            cs.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Ejecuta un procedimiento almacenado 
     * @param sp_name Nombre del procedimiento almacenado
     * @param aParam Parámetros del procedimiento almacenado
     */
    public void sp_proc(String sp_name, String aParam) {
        try {
            CallableStatement cs = this.conexion.prepareCall(sp_name);
            cs.setString(1, aParam);
            cs.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

